UNISUL
DAVI SAMUEL DA SILVA
PEDRO HENRIQUE LIMA DE ARAÚJO
SISTEMA DE GERENCIAMENTO DE ESTOQUE
Florianópolis
2025
DAVI SAMUEL DA SILVA
PEDRO HENRIQUE LIMA DE ARAÚJO
SISTEMA DE GERENCIAMENTO DE ESTOQUE
Trabalho A3 apresentado ao Curso de
Programação de Soluções Computacionais da
Unisul como como parte das atividades
acadêmicas do semestre [1° de 2025].
Orientador: Prof. Nome do Professor, Dr./Ms./Bel./Lic.
Florianópolis
2025
RESUMO
Este trabalho desenvolve um Sistema de Gerenciamento de Estoque em Java para otimizar o
controle de produtos em pequenos negócios. A necessidade de substituir planilhas manuais por
uma solução automatizada que evita erros e perdas. O objetivo central foi criar uma ferramenta
intuitiva para cadastrar produtos/categorias, controlar níveis de estoque (mínimo/máximo) e
gerar relatórios estratégicos. O método adotou a arquitetura Model-View-DAO, com interface
gráfica em Swing e banco de dados MySQL, validada através de testes manuais e simulações
de uso. Alertas automáticos para estoque baixo/excesso e relatórios financeiros precisos. Com
potencial para expansão com leitores de código de barras e módulo de compras.
Palavras-chave: Controle de Estoque. Sistema Java. Gestão de Produtos. Relatórios
Gerenciais. Automação Comercial.
RESUMO ................................................................................................................................... 2
1 INTRODUÇÃO ................................................................................................................ 5
1.1 ANÁLISE DO SITEMA ................................................................................................ 6
1.2 REQUISITOS FUNCIONAIS ........................................................................................ 6
1.3 REQUISITOS NÃO FUNCIONAIS .............................................................................. 6
1.4 REGRAS DE NEGÓCIO ............................................................................................... 6
1.5 TABELA DE ESPECIFICAÇOES DE REQUISITOS. ................................................. 7
1.6 CASO DE USO .............................................................................................................. 7
1.7 CLASSES ....................................................................................................................... 9
1.8 DIAGRAMA DE FLUXO............................................................................................ 12
1.8.1 Início do Sistema .................................................................................................... 12
1.8.2 Cadastro de Produtos ............................................................................................ 12
1.8.3 Controle de Estoque ............................................................................................... 12
1.8.4 Relatórios ................................................................................................................ 12
1.8.5 Persistência e Conexões ......................................................................................... 12
1.8.6 Validações e Feedback ........................................................................................... 13
1.8.7 Encerramento ......................................................................................................... 13
1.9 MODELAGEM DE DADOS ....................................................................................... 15
2 DESENVOLVENDO O SISTEMA. .............................................................................. 17
2.1 BACK-END.................................................................................................................. 17
2.1.1 Models (Modelos) ................................................................................................... 17
2.1.1.1 Categoria.java .......................................................................................................... 17
2.1.1.2 Produto.java ............................................................................................................. 18
2.1.1.3 Relatorio.java ........................................................................................................... 19
2.1.2 DAO (Data Access Object) .................................................................................... 21
2.1.2.1 Categoria.DAO. ....................................................................................................... 22
2.1.2.2 Produto.DAO ........................................................................................................... 23
2.1.2.3 ConnectionFactory ................................................................................................... 25
2.2 FRONT-END................................................................................................................ 26
2.2.1 Menu Principal ....................................................................................................... 29
2.2.2 Gerenciar Categorias ............................................................................................. 30
2.2.3 Gerenciar Produtos ................................................................................................ 31
2.2.4 Relatórios ................................................................................................................ 33
2.2.5 Encerramento do Sistema ..................................................................................... 33
3 REFERENCIAS.............................................................................................................. 35
3.1 LIVROS ........................................................................................................................ 35
3.2 DOCUMENTOS INSTITUCIONAIS .......................................................................... 35
3.3 ARTIGOS ONLINE ..................................................................................................... 35
3.4 REPOSITÓRIOS GITHUB .......................................................................................... 35
5
1 INTRODUÇÃO
A gestão eficiente de estoques representa um desafio crítico para micro e pequenas
empresas, onde processos manuais frequentemente resultam em erros operacionais, perdas
financeiras e rupturas de suprimentos. Este trabalho desenvolve e implementa um Sistema de
Controle de Estoque utilizando Java e padrões de arquitetura fundamentado no padrão Model-
View-DAO (MVD), o sistema organiza-se em três camadas interconectadas: a camada Model
(entidades como Produto e Categoria com validações de negócio, exemplificada pelo método
setQuantidadeMinima(int min) que assegura valores positivos), a camada DAO (operações de
persistência atômica via JDBC, como deletar(int id) em ProdutoDAO.java que previne SQL
Injection com PreparedStatement), e a camada View (interface gráfica em Swing com feedback
imediato, como a validação em tempo real em atualizarQuantidade(int operacao) de
ProdutoView.java). Os objetivos específicos incluíram: (a) automatização de operações CRUD
para produtos/categorias, (b) controle preventivo de níveis mínimo/máximo de estoque, e (c)
geração dinâmica de relatórios estratégicos (implementados em RelatorioView.java com abas
para balanço financeiro e lista de preços dentre outras). A metodologia adotou desenvolvimento
iterativo em três etapas: modelagem conceitual, implementação progressiva das camadas, e
refinamento baseado em testes manais. Fornece alertas preventivos para estoques críticos.
¹ Uma transação atômica é aquela que ocorre de forma indivisível: ou todas as suas mudanças são aplicadas com sucesso
(COMMIT), ou são completamente revertidas (ROLLBACK), garantindo a integridade dos dados.
6
1.1 ANÁLISE DO SITEMA
1.2 REQUISITOS FUNCIONAIS
1. Gerenciamento de Produtos - Cadastrar, editar, consultar e excluir produtos com
os campos: Nome, Preço unitário, Unidade de medida, Quantidade em estoque,
Quantidade mínima, Quantidade máxima e Categoria.
2. Gerenciamento de Categorias - Cadastrar, editar, consultar e excluir categorias
com os campos: Nome, Tamanho (Pequeno/Médio/Grande) e Embalagem
(Lata/Vidro/Plástico).
3. Controle de Movimentações - Registrar entrada/saída de produtos com alertas
automáticos para estoque abaixo do mínimo ou acima do máximo.
4. Ajuste de Preços - Aplicar reajuste percentual em todos os produtos
simultaneamente.
5. Relatórios - Gerar: Lista de Preços, Balanço Físico/Financeiro, Produtos
abaixo/sobre estoque e Quantidade por categoria, todos ordenados alfabeticamente.
1.3 REQUISITOS NÃO FUNCIONAIS
1. Banco de Dados - Armazenar produtos, categorias e movimentações.
2. Interface - Telas para CRUD, movimentações e relatórios.
3. Desempenho - Tempo de resposta adequado para operações diárias.
4. Validações - Impedir cadastros incompletos e quantidades mínimas / máximas.
1.4 REGRAS DE NEGÓCIO
1. Atualizar estoque automaticamente (entradas aumentam, saídas diminuem).
2. Emitir alertas quando estoque estiver abaixo do mínimo ou acima do máximo.
3. Todo produto deve ter categoria vinculada.
4. Bloquear saídas sem estoque suficiente.
5. Relatórios sempre em ordem alfabética por nome.
7
1.5 TABELA DE ESPECIFICAÇOES DE REQUISITOS.
Tabela 1 (Especificações de requisitos)
Componente
Detalhes
FUNCIONALIDAD
ES
- CRUD completo de produtos e categorias
- Movimentações com alertas (mínimo/máximo)
- Relatórios: lista de preços, balanço, níveis de
estoque
DEPENDÊNCIAS
- Vinculação obrigatória entre produto e categoria
VALIDAÇÕES
- Frontend: Combobox de categorias
- Regras: Verificações no DAO
- Banco de Dados: Chave estrangeira (FK)
REGRAS DE
NEGÓCIO
- Bloqueio de exclusão de categorias com produtos
- Alertas automáticos de estoque
ARQUITETURA
- Base para modelagem do BD e classes de
domínio
- Define contratos de interface
1.6 CASO DE USO
O diagrama abaixo, após a tabela de especificação do caso de uso, destaca as
dependências críticas do sistema, particularmente a relação obrigatória entre
produtos e categorias, onde todo produto deve estar vinculado a uma categoria
previamente cadastrada. Essa dependência é implementada através de três
mecanismos de validação: uma combobox na interface do usuário (ProdutoView)
que limita a seleção a categorias existentes, verificações no ProdutoDAO para
garantir a integridade dos dados, e a chave estrangeira no banco de dados que
mantém o relacionamento.
Além de definir o escopo, o diagrama documenta importantes regras de
negócio, como os alertas automáticos para estoque abaixo do mínimo ou acima do
máximo durante as movimentações, e a restrição que impede a exclusão de
categorias que possuam produtos vinculados.
Essas validaçõessão representadas tanto visualmente no diagrama quanto em
notas explicativas complementares.Como artefato central da análise, este diagrama
8
de casos de uso fornece os requisitos necessários para a modelagem subsequente do
sistema, incluindo a definição das classes de domínio, o design da camada de
persistência e os contratos de interface. Ele estabelece claramente os limites do
sistema e serve como referência para toda a equipe de desenvolvimento, garantindo
que todas as funcionalidades essenciais sejam adequadamente implementadas e
integradas.
Tabela 2 (especificação do diagrama do caso de uso)
Caso de uso
Descrição
Gerenciar categorias
Adicionar/Editar/Listar/Rem
ovr categorias (validação:
não remover com produtos
ativos)
Gerencia produtos
CRUD de produtos com
vinculação obrigatória a
categorias (combobox + FK)
Registrar movimentações
Entrada e saída com
validações de estoque
mínimo e máxix’mo
Gerar relatórios
Listas de preços, balanço e
níveis de estoque (sempre
ordenados alfabeticamente)
Validação do sistema
Garantir integridade:
1- FrontEnd: Combobox
2- BackEnd: Verificação no
DAO
3- Banco de Dados: Chave
estrangeira
Imagem 1 (Diagrama de caso de uso)
9
1.7 CLASSES
O diagrama de classes representa o sistema de gestão, desenvolvido com base em
princípios de modularidade, separação de responsabilidades e reutilização de código. A
10
arquitetura adotada segue um padrão Model-View-DAO (MVD), implícito, organizando o
sistema em três camadas principais: interface gráfica (View), lógica de negócios (Model) e
acesso a dados (DAO). Essa divisão garante maior clareza no desenvolvimento, facilitando a
manutenção e a escalabilidade do software.
As Views (CategoriaView, ProdutoView e RelatorioView) são responsáveis pela
interação com o usuário, exibindo dados e capturando entradas. Elas se comunicam com os
DAOs (CategoriaDAO e ProdutoDAO), que, por sua vez, gerenciam todas as operações de
persistência no banco de dados. A ConnectionFactory atua como um ponto centralizado para
conexões com o banco, seguindo o padrão Singleton para evitar múltiplas instâncias
desnecessárias e otimizar o uso de recursos.
² O Singleton garante que uma classe tenha apenas uma instância globalmente acessível, melhorando o
desempenho e evitando conflitos na execução.
Imagem 2 (diagrama de classe)
11
12
1.8 DIAGRAMA DE FLUXO
1.8.1 Início do Sistema
O usuário inicia o sistema pelo Menu Principal, que oferece opções de gestão. Ao
selecionar "Gerenciar Categorias", o sistema carrega a tela específica e consulta o banco de
dados para exibir as categorias existentes através do CategoriaDAO. Castra produtos
preenchendo o formulário. Executa o INSERT no banco de dados.
1.8.2 Cadastro de Produtos
Ao acessar "Gerenciar Produtos", o sistema primeiro carrega as categorias disponíveis
(pré-requisito essencial) antes de exibir os produtos existentes. Para cadastrar um novo produto,
o usuário preenche todos os campos do formulário, incluindo a seleção de uma categoria válida
campos validos. Executa o INSERT no banco de dados. Alertas, erros e sucessos são gerados.
1.8.3 Controle de Estoque
Na tela de produtos, movimentações de estoque são realizadas através dos botões
"Entrada" (aumento) e "Saída" (redução). O sistema solicita a quantidade, valida contra o
estoque atual e limites configurados, e executa o UPDATE no banco via ProdutoDAO. Alertas,
erros e sucessos são gerados.
1.8.4 Relatórios
A opção "Relatórios" aciona consultas específicas no banco de dados para cada tipo de
análise (lista de preços, balanço, produtos por categoria, e alertas de estoque). O ProdutoDAO
transforma os ResultSets em objetos Relatorio, que são formatados e exibidos em abas
separadas.
1.8.5 Persistência e Conexões
A ConnectionFactory centraliza o gerenciamento de conexões com o banco, seguindo o
padrão Singleton. Todos os DAOs utilizam esta fábrica para obter conexões, que são
automaticamente fechadas após cada operação.
13
1.8.6 Validações e Feedback
Em cada etapa, o sistema realiza validações de dados (campos obrigatórios, formatos
numéricos, consistência de estoque) e fornece feedback imediato ao usuário através de
mensagens dialógicas. A interface é atualizada automaticamente após operações bem-
sucedidas.
1.8.7 Encerramento
A saída do sistema encerra completamente a aplicação, garantindo que todas as
conexões com o banco sejam finalizadas e recursos liberados.
Imagem 3 (diagrama de fluxo)
14
15
1.9 MODELAGEM DE DADOS
O código SQL inicia com a criação do banco de dados db_estoque e sua seleção imediata
para uso. Em seguida, define-se a tabela produto com os campos essenciais para o
armazenamento de informações sobre os itens em estoque. Cada produto possui um
identificador único gerado automaticamente (id), nome, preço unitário, unidade de medida,
quantidade atual em estoque, níveis mínimo e máximo de estoque.
Posteriormente, cria-se a tabela categoria para classificar os produtos. Esta tabela inclui
identificador único autoincrementável, nome (com restrição de unicidade para evitar
duplicatas), tamanho (com valores pré-definidos "Pequeno", "Médio" ou "Grande" e padrão
"Médio"), e tipo de embalagem (obrigatoriamente "Lata", "Plástico" ou "Vidro").
Por fim, estabelece a relação entre as tabelas através de uma chave estrangeira. O campo
categoria_id na tabela produto é vinculado ao id da tabela categoria, criando uma associação
onde cada produto pode pertencer a uma categoria específica. Esta estrutura relacional organiza
os dados de forma coesa, permitindo consultas eficientes e mantendo a consistência entre
produtos e suas categorias correspondentes, base para todo o sistema de gestão de estoque.
Imagem 4 (script SQL)
Modelo Entidade-Relacionamento:
Imagem 5 (diagrama ER)
16
17
2 DESENVOLVENDO O SISTEMA.
2.1 BACK-END
2.1.1 Models (Modelos)
O primeiro passo para o desenvolvimento do sistema em questão é a criação das classes que
servirão de modelo. As classes Produto e Categoria constituem a espinha dorsal do modelo de
dados do sistema.
A classe Categoria.java define grupos lógicos para organização do estoque,
encapsulando propriedades essenciais como identificador único, nome descritivo, classificação
dimensional e tipo de embalagem. Sua estrutura simples e autônoma permite a categorização
eficiente de itens sem complexidades operacionais.
A classe Produto.java representa os itens físicos gerenciados pelo sistema,
incorporando atributos como código identificador, denominação, valor unitário, unidade de
medida e controles de estoque (quantidades atual, mínima e máxima). A conexão entre ambas
as classes se materializa através de uma associação direta, onde cada produto se vincula a uma
categoria específica, estabelecendo hierarquia e organização no inventário.
A classe Relatorio.java desempenha um papel fundamental como modelo
especializado para transferência de dados consolidados, se diferenciando das demais entidades
por sua natureza híbrida e orientada a análise. Ao contrário de Produto e Categoria, que
representam entidades de negócio puras, esta classe atua como um contêiner de dados
agregados, projetado exclusivamente para suportar a geração de relatórios estratégicos. Foco
em DTO (Data Transfer Object): Cada construtor corresponde a uma consulta específica do
sistema, permitindo que o ProdutoDAO retorne dados já estruturados para a camada de
visualização RelatorioView.
Note que os construtores se diferenciam por suas assinaturas de métodos.
2.1.1.1 Categoria.java
O primeiro construtor é essencial para a aplicação porque, em primeiro momento, não
há ID’s. Isso permite que o objeto seja instanciado sem nem um dado armazenado no banco:
Imagem 6(construtor Categori.java)
18
Seguido de seus Getters e Setters:
Imagem 7(Getters e Setters Categoria.java)
2.1.1.2 Produto.java
Da mesma forma que o construtor sem ID na Categoria.java, no Produto.java também serve um
construtor sem ID para instanciar o objeto sem dados prévios:
Imagem 8 (Construtores Produto.java)
19
E seus Getters e Setters:
Imagem 9(Getters e Setters Produto.java)
2.1.1.3 Relatorio.java
Para atender aos diferentes tipos de relatórios, foram implementados construtores
específicos na classe Relatório, cada um inicializando apenas os campos necessários para cada
cenário.
Assinatura do construtor [0]: nome do produto, preço unitário, unidade de medida e
categoria:
Imagem 10(construtor [0] Relatori.java)
20
Assinatura do construtor [1]: nome do produto, quantidade em estoque, preço
unitário e valor total do estoque:
Imagem 11 (construtor [1] Relatori.java)
Assinatura do construtor [2]: nome do produto, quantidade em estoque, quantidade
máxima e quantidade mínima:
Imagem 12 (construtor [2] Relatori.java)
Assinatura do construtor [3]: categoria e quantidade de produto:
Imagem 13 (construtor [3] Relatori.java)
Aqui há uma diferença entre os modelos de Produtos e Categorias. Nos Relatórios é feita apenas
as consultas no banco de dados( Getters). Não necessitando de Setters:
Imagem 14 (Getters Relatori.java)
21
2.1.2 DAO (Data Access Object)
As classes CategoriaDAO, ProdutoDAO e ConnectionFactory constituem a
infraestrutura de persistência do sistema, atuando como mediadoras entre o modelo de domínio
e o banco de dados. Sua arquitetura segue princípios de coesão e encapsulamento, onde cada
DAO assume responsabilidades específicas de manipulação de dados para sua respectiva
entidade.
A CategoriaDAO concentra-se na gestão de grupos lógicos do estoque, implementando
operações essenciais com validação de integridade. Seu diferencial está na prevenção de
exclusões que comprometam a consistência dos dados, garantindo que categorias vinculadas a
produtos não sejam removidas inadvertidamente. Além das operações básicas de CRUD,
oferece funcionalidades estratégicas como a identificação automática de novos ID’s e listagem
ordenada para otimização de interfaces.
O ProdutoDAO destaca-se pela complexidade operacional, gerenciando não apenas o
ciclo de vida dos produtos, mas também regras de negócio críticas. Implementa:
Controle dinâmico de estoque com validação de saldo negativo
Geração de relatórios estratégicos (balanço financeiro, níveis de estoque)
Operações em massa como reajuste percentual de preços
Recuperação de dados associados via JOINs com categorias
Sua estrutura reflete a natureza central dos produtos no sistema, integrando métricas
operacionais e financeiras.
A ConnectionFactory atua como alicerce técnico, abstraindo a complexidade de
conexões JDBC. Seu design Factory Method simplifica a manutenção de credenciais e promove
22
reuso em toda a camada de persistência. A capacidade de testar conexões agiliza a detecção de
problemas de infraestrutura.
A classe ConnectionFactory segue o padrão de criação Factory Method, encapsulando
a lógica de conexão e permitindo maior reutilização e manutenção centralizada. Isso
evita a repetição de código em cada DAO e melhora a escalabilidade do sistema.”
(MERC, 2025)
2.1.2.1 Categoria.DAO.
Dentre os 8 métodos que há na classe se destaca o de inserção, usa a própria conexão para
retornar os ID’s atualizados:
Imagem 15 (Método inserir Relatori.java)
Tabela de comparação entre os métodos na Categori.DAO:
Tabela 3 (comparação entre os métodos na Categoria.DAO)
Método
Ação CRUD
Descrição Resumida
Parâmetros
Retorno
Inserir
CREATE
Adiciona novo registro
Objeto
Categoria
boolean
(sucesso)
Atualizar
UPDATE
Modifica registro
existente
Objeto
Categoria
boolean
(sucesso)
23
Deletar
DELETE
Remove registro (com
verificação)
ID (int)
boolean
(sucesso)
BuscarPorId
READ
Recupera um registro por
ID
ID (int)
Categoria ou null
listarTodos
READ
Recupera todos os
registros
—
List<Categoria>
GetMinhaLista
READ
Lista todos (formato
alternativo)
—
ArrayList<Categ
oria>
maiorID
Auxiliar
Retorna o maior ID
usado
—
int
ExistemProdut
osAssociados
Auxiliar
Verifica produtos
vinculados
ID (int)
boolean
2.1.2.2 Produto.DAO
No Produto.DAO que se destaca por implementar uma regra de negócio crítica (controle de
estoque) com validação de integridade e operação atômica, atendendo aos requisitos funcionais
RF3 e regras de negócio RN2/RN4. É o atualizarQuantidade().
Imagem 16 (método que muda o estado da quantidade na tabela produto)
24
Tabela de comparação entre os métodos na Categoria.DAO:
Tabela 34(comparação entre os métodos na Produto.DAO)
Método
Ação
CRUD
Descrição Resumida
Parâmetros
Retorno
inserir
CREATE
Adiciona um novo produto ao
banco de dados
Objeto Produto
boolean
(sucesso)
atualizar
UPDATE
Modifica um produto existente
Objeto Produto
boolean
(sucesso)
deletar
DELETE
Remove um produto pelo ID
ID (int)
boolean
(sucesso)
buscarPorId
READ
Recupera um produto específico
pelo ID (com dados da categoria
associada)
ID (int)
Produto
ou null
listarTodos
READ
Recupera todos os produtos (com
informações de categoria)
—
List<Prod
uto>
25
getMinhaLista
READ
Lista todos os produtos (formato
alternativo: ArrayList)
—
ArrayList
<Produto
>
maiorID
Auxiliar
Retorna o maior ID de produto
cadastrado
—
int
atualizarQuanti
dade
UPDATE
Ajusta a quantidade em estoque
(com verificação para valores
negativos)
ID (int),
quantidadeVariaca
o (int)
boolean
(sucesso)
listarAbaixoDo
Minimo
READ
Lista produtos com quantidade
abaixo do mínimo definido
—
List<Prod
uto>
listarAcimaDo
Maximo
READ
Lista produtos com quantidade
acima do máximo definido
—
List<Prod
uto>
gerarListaPrec
os
READ
Gera relatório de preços (nome,
preço, unidade e categoria)
—
List<Rela
torio>
gerarBalanco
READ
Calcula valor total em estoque
(quantidade × preço)
—
List<Rela
torio>
gerarProdutosP
orCategoria
READ
Conta produtos por categoria
—
List<Rela
torio>
reajustarPrecos
UPDATE
Aplica reajuste percentual em
todos os preços
2.1.2.3 ConnectionFactory
Configurações para o banco de dados de forma global no sistema. Passando somente uma vez
as credenciais:
Imagem 17 (Configuração do banco de dados ConnectionFactory )
26
Método para gerar uma conceção com as credenciais passadas nos atributos:
Imagem 18 (Método para obter uma conexão)
E por fim, o método par disparar exceções em relação à conceção com o BD:
Imagem 19 (Método para teste de conexão)
2.2 FRONT-END.
O front-end do Sistema de Gerenciamento de Estoque foi desenvolvido utilizando
Java Swing, com ênfase no componente DefaultTableModel para implementação de tabelas
27
dinâmicas e interativas. Essa escolha técnica proporcionou uma gestão flexível e eficiente dos
dados em tempo de execução, atendendo aos requisitos críticos de um sistema de controle de
estoque.
A classe DefaultTableModel (pacote javax.swing.table) foi fundamental para
implementar as funcionalidades como:
Atualização em tempo real dos dados de produtos, categorias e relatórios
Manipulação programática de linhas e colunas sem recarregar a interface
Validação de edições através da sobrescrita do método isCellEditable()
Exemplo de implementação em RelatorioView.java:
Imagem 20 (Metdo criar PainelListairecos em RelatorioView.java)
Vantagens do DefaultTableModel no Contexto do Projeto
Atualização Dinâmica de Estoque
Adição/remoção imediata de produtos na tabela após movimentações
Cálculo automático de totais no relatório de balanço
Desempenho em Operações CRUD
Métodos otimizados (addRow(), removeRow(), setValueAt())
Notificação automática de mudanças para a interface gráfica
Integração com Regras de Negócio
28
Bloqueio de edição direta em colunas críticas (ex: ID)
Bloqueio de edição direta em colunas críticas (ex: ID)
Integração com Regras de Negócio
Bloqueio de edição direta em colunas críticas (ex: ID)
Formatação condicional de valores monetários e quantitativos
Customização Extensível
Possibilidade de criar modelos especializados herdando de AbstractTableModel
Suporte a tipos de dados heterogêneos na mesma tabela
A implementação com DefaultTableModel permitiu:
Feedback visual imediato após operações de estoque
Ordenação e filtragem sem necessidade de recarregar dados
Consistência entre os dados exibidos e o estado do banco de dados
Segundo a documentação oficial da Oracle (2025), componentes maduros do Swing
continuam sendo eficazes para aplicações empresariais que exigem tabelas complexas
e atualização frequente de dados.
Interfaces visuais
A aplicação inicia pela interface principal, denominada Menu Principal, onde são
renderizados quatro botões principais que permitem o acesso às seguintes funcionalidades:
Gerenciar Categorias
Gerenciar Produtos
Gerenciar Relatórios
Sair
Imagem 21 (diagrama de navegação)
29
2.2.1 Menu Principal
O Menu Principal serve como ponto de entrada do sistema, permitindo a navegação
para as demais telas da aplicação. Os botões são dispostos de forma clara e acessível,
proporcionando uma experiência amigável ao usuário.
Imagem 22 (Tela Menu)
30
2.2.2 Gerenciar Categorias
Ao acessar a opção Gerenciar Categorias, o usuário pode realizar as operações de criação,
edição e remoção de categorias. Cada categoria possui os seguintes campos obrigatórios:
Nome da categoria
Tamanho: Pequeno, Médio ou Grande
Tipo de embalagem: Lata, Vidro ou Plástico
Abaixo é exibida a planilha das categorias já cadastradas. É possível clicar em uma linha para
editar ou remover a categoria, desde que não haja um produto associado a ela.
Imagem 23 (Tela Categorias)
31
2.2.3 Gerenciar Produtos
Na seção Gerenciar Produtos, o usuário pode adicionar, editar e remover produtos do
estoque. Os campos disponíveis são:
Nome do produto
Preço unitário
Unidade: Unidade, Quilograma ou Litro (selecionados via botões de rádio)
Quantidade em estoque
Estoque mínimo e máximo
Categoria associada (selecionada via ComboBox, sendo obrigatório ter categorias
previamente cadastradas)
32
Além do CRUD de produtos, essa tela permite a entrada e saída de estoque, bem como a
realização de reajuste de preços de forma manual.
Restrições:
Não é possível cadastrar produtos sem antes ter ao menos uma categoria cadastrada.
Campos obrigatórios devem estar corretamente preenchidos.
A quantidade de estoque deve respeitar os limites definidos (mínimo e máximo).
Imagem 23 (Tela Produtos)
33
2.2.4 Relatórios
A interface de relatórios é organizada em abas, oferecendo diferentes visões dos dados do
sistema:
Lista de Preços: Exibe nome, preço, unidade e categoria dos produtos.
Balanço de Estoque: Mostra produtos com suas quantidades e o valor total (quantidade × preço).
Produtos por Categoria: Indica a quantidade de produtos cadastrados por categoria.
Abaixo do Mínimo: Lista produtos com estoque inferior ao mínimo definido.
Acima do Máximo: Aponta produtos com quantidade acima do limite máximo.
As tabelas são atualizadas automaticamente após qualquer alteração no banco de dados,
garantindo informações consistentes e em tempo real.
Imagem 24 (Tela relatórios)
2.2.5 Encerramento do Sistema
O botão Sair, disponível no Menu Principal, encerra completamente a aplicação, finalizando a
execução do sistema de forma segura e imediata.
Imagem 22 (Botão sair)
34
35
3 REFERENCIAS
3.1 LIVROS
PRESSMAN, Roger S. Engenharia de software: uma abordagem profissional. 8. ed. Porto
Alegre: McGraw-Hill, 2019.
3.2 DOCUMENTOS INSTITUCIONAIS
ORACLE. Java SE 8: DefaultTableModel. Disponível em:
https://docs.oracle.com/javase/8/docs/api/javax/swing/table/DefaultTableModel.html. Acesso
em: 14 maio 2025.
ORACLE. JDBC Basics. Disponível em: https://docs.oracle.com/javase/tutorial/jdbc/basics/.
Acesso em: 14 maio 2025.
MYSQL. MySQL 8.0 Reference Manual. Disponível em:
https://dev.mysql.com/doc/refman/8.0/en/. Acesso em: 14 maio 2025.
3.3 ARTIGOS ONLINE
GEEKSFORGEEKS. Java Swing | Formulário de Registro de Usuário Simples. Disponível em:
https://www.geeksforgeeks.org/java-swing-user-registration-form/. Acesso em: 15 maio 2025.
GUJ. ConnectionFactory JDBC – Boas ideias para melhorar a classe. Disponível em:
https://www.guj.com.br/t/connectionfactory-jdbc-boas-ideias-para-melhorar-a-classe/294712.
Acesso em: 14 maio 2025.
3.4 REPOSITÓRIOS GITHUB
MERC, Tiago. Java e JDBC: trabalhando com um banco de dados – ALURA. GitHub, 2025.
Disponível em: https://github.com/TiagoMerc/Java-e-JDBC-trabalhando-com-um-banco-de-
dados-ALURA. Acesso em: 14 jun. 2025.
PEIXOTO, Maria. JFrame Projects. GitHub, 2025. Disponível em:
https://github.com/mariacpeixoto/JFrame-projects. Acesso em: 18 maio 2025.
36
Outras Referências
JAVAMEX. InvokeLater em Java. Disponível em:
https://www.javamex.com/tutorials/threads/invokelater.shtml. Acesso em: 14 maio 2025.
Vídeos
SILVA, Cryswerton. Curso de Java Básico. YouTube, 2025. Disponível em:
https://www.youtube.com/watch?v=r8Vhn_yWTMo. Acesso em: 14 maio 2025.
CARLOS HENRIQUE JAVA. Introdução ao JDBC em Java. YouTube, 2025. Disponível em:
https://www.youtube.com/watch?v=FES8Cwl3LFs. Acesso em: 14 maio 2025.